home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 8 / QRZ Ham Radio Callsign Database - Volume 8.iso / pc / files / p_misc / 7p203upp.exe / V203SRC.LZH / UTILS.C < prev   
C/C++ Source or Header  |  1992-07-17  |  30KB  |  1,422 lines
  1. #include "7plus.h"
  2. #include "globals.h"
  3.  
  4. #ifdef __unix__
  5.  #ifdef __M_XENIX__
  6.   struct utimbuf {
  7.    time_t actime;
  8.    time_t modtime;
  9.   };
  10.   extern time_t mktime (struct tm *utm);
  11.  #else
  12.   #include <utime.h>
  13.  #endif
  14. #endif
  15.  
  16. static char no[] = NO, yes[] = YES, always[] = ALWAYS;
  17.  
  18. /*
  19. *** get a line from file. don't care about type of line separator.
  20. ***
  21. ***
  22.  */
  23.  
  24. char *my_fgets (char *string, register n, FILE *rein)
  25. {
  26.   register in, i;
  27.  
  28.   if (feof (rein))
  29.     return (NULL);
  30.  
  31.   i = 0;
  32.   while ((in = fgetc (rein)) != EOF)
  33.   {
  34.     if (in == 0x0d)
  35.     {
  36.       if ((in = fgetc (rein)) != 0x0a)
  37.         if (in != EOF)
  38.           ungetc (in, rein);
  39.       in = 0x0a;
  40.     }
  41.     string[i++] = (char) in;
  42.     if (i == n || in == 0x0a)
  43.       break;
  44.   }
  45.   string[i] = EOS;
  46.   return (string);
  47. } 
  48.  
  49. /*
  50. ***
  51. *** Write a byte to file.
  52. ***
  53.  */
  54.  
  55. int my_putc (int outchar, FILE *out)
  56. {
  57.   register x;
  58.  
  59.   if ((x = putc ((char) outchar, out)) == EOF)
  60.   {
  61.     printf ("\007\nWrite error! Can't continue.\n");
  62.     exit (1);
  63.   }
  64.   return (x);
  65. }
  66.  
  67. /*
  68. *** Get crc and line number from code line.
  69. ***
  70. ***
  71.  */
  72.  
  73. void crc_n_lnum (uint *crc, int *linenumber, char *line)
  74. {
  75.   register ulong cs;
  76.  
  77.   cs = 0xb640L * decode[(byte)line[66]] +
  78.        0xd8L   * decode[(byte)line[65]] +
  79.                  decode[(byte)line[64]];
  80.  
  81.   *linenumber = (int) (cs >> 14);   /* upper 9 bits are the line number */
  82.   *crc = (uint) (cs & 0x3fffL);     /* lower 14 bits are the CRC */
  83. }
  84.  
  85. /*
  86. *** Get crc2 from code line.
  87. ***
  88. ***
  89.  */
  90.  
  91. void crc2 (uint *crc, char *line)
  92. {
  93.  
  94.   *crc = 0xd8 * decode[(byte)line[68]] +
  95.                 decode[(byte)line[67]];
  96. }
  97.  
  98. /*
  99. *** Whip up 2nd CRC
  100. ***
  101. ***
  102.  */
  103.  
  104. void add_crc2 (char *line)
  105. {
  106.   register uint crc;
  107.   register int i;
  108.  
  109.   /* Whip up 2nd CRC */
  110.   crc = 0;
  111.   for (i=66;i>-1;i--)
  112.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte) line[i]);
  113.   crc &= 0x7fff;
  114.  
  115.   i = 67;
  116.   line[i++] = code[crc % 0xd8];
  117.   line[i++] = code[crc / 0xd8];
  118.   line[i] = EOS;
  119. }
  120.  
  121. /*
  122. *** mini-crc for header. safe enough...
  123. ***
  124. ***
  125.  */
  126.  
  127. int mcrc (char *line, int flag)
  128. {
  129.   register int i, j;
  130.   register uint crc;
  131.   char test[3], *p;
  132.  
  133.   sprintf (test, "\xb0\xb1");
  134.  
  135.   if ((p = strstr (line, test)) == NULL)
  136.     return (0);
  137.  
  138.   j = (int) (p - line) + 4;
  139.  
  140.   for (i=crc=0; i<j; i++)
  141.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  142.   crc %= 216;
  143.   if (!flag)
  144.   {
  145.     if (crc == (uint) decode[(byte)line[j]])
  146.       return (1);
  147.     else
  148.       return (0);
  149.   }
  150.   else
  151.     line[j] = code[(byte)crc];
  152.  
  153.   return (crc);
  154. }
  155.  
  156. /*
  157. *** read info from indexfile
  158. ***
  159. ***
  160.  */
  161.  
  162. int read_index (FILE *ifile, struct m_index *index)
  163. {
  164.   int j;
  165.   ulong i, begin, end;
  166.  
  167.   #ifdef _CHSIZE_OK
  168.    fseek (ifile, -4L, SEEK_END);
  169.    fseek (ifile, read_ulong (ifile), SEEK_SET);
  170.   #endif
  171.  
  172.   /* clear index */
  173.   for (j = 0;j < 4080; j++)
  174.     index->lines_ok[j] = 0UL;
  175.  
  176.   my_fgets (index->full_name, 12, ifile);
  177.   if (strcmp(index->full_name, "7PLUS-index\x0a"))
  178.   {
  179.     printf ("\007No index info found.\n");
  180.     return (1);
  181.   }
  182.   my_fgets (index->filename, 13, ifile);
  183.   index->filename[(int)strlen(index->filename)-1] = EOS;
  184.   my_fgets (index->full_name, 257, ifile);
  185.   index->full_name[(int)strlen(index->full_name)-1] = EOS;
  186.   index->timestamp = read_ulong (ifile);
  187.   index->splitsize = read_uint  (ifile);
  188.   index->lines_left= (long) read_ulong (ifile);
  189.  
  190.   /* convert defect list into bitvektor */
  191.   while (1==1)
  192.   {
  193.     if ((begin = read_ulong (ifile)) == 0xffffffffUL)
  194.       break;
  195.     end = read_ulong (ifile);
  196.  
  197.     if ((end>>5) > (begin>>5))
  198.       for (i = begin;i < ((begin |31UL) + 1UL); i++)
  199.         index->lines_ok[(int)i>>5] |= (1UL <<(i&31UL));
  200.     else
  201.     {
  202.       for (i = begin;i < end; i++)
  203.         index->lines_ok[(int)i>>5] |= (1UL <<(i&31UL));
  204.       continue;
  205.     }
  206.  
  207.     for (i = (begin>>5) +1; i < (end>>5); i++)
  208.       index->lines_ok[(int)i] = 0xffffffffUL;
  209.  
  210.     if (end&31)
  211.       for (i = end &0xffffffe0UL; i < end; i++)
  212.         index->lines_ok[(int)i>>5] |= (1UL <<(i&31UL));
  213.   }
  214.   index->length = read_ulong (ifile);
  215.  
  216.   #ifdef _CHSIZE_OK
  217.    fseek (ifile, 0UL, SEEK_SET);
  218.   #endif
  219.  
  220.   return (0);
  221. }
  222.  
  223. /*
  224. *** write info to indexfile
  225. ***
  226. ***
  227.  */
  228.  
  229. int write_index (FILE *ifile, struct m_index *index, int flag)
  230. {
  231.   int j, part, prevpart, lines;
  232.   ulong i, begin, end;
  233.  
  234.   part = prevpart = lines = 0;
  235.   begin = end = 0UL;
  236.  
  237.   if (!flag)
  238.   {
  239.     #ifdef _CHSIZE_OK
  240.      fseek (ifile, index->length, SEEK_SET);
  241.     #endif
  242.  
  243.     fprintf (ifile, "7PLUS-index\n");
  244.     fprintf (ifile, "%s\n", index->filename);
  245.     fprintf (ifile, "%s\n", index->full_name);
  246.     write_ulong (ifile, index->timestamp);
  247.     write_uint  (ifile, index->splitsize);
  248.     write_ulong (ifile, (ulong) index->lines_left);
  249.   }
  250.   /* convert bitvektor into defect list */
  251.   i = 0UL;
  252.   j = 0;
  253.   while (1==1)
  254.   {
  255.     while (j < 4080 && !(index->lines_ok[j] &(1UL <<(i & 31UL))))
  256.     {
  257.       if (!(i&31UL) && index->lines_ok[j] == 0UL)
  258.       {
  259.         j++;
  260.         i = (ulong) j<<5;
  261.       }
  262.       else
  263.       {
  264.         i++;
  265.         j = (int) i>>5;
  266.       }
  267.     }
  268.  
  269.     if (j == 4080)
  270.       break;
  271.  
  272.     begin = i;
  273.  
  274.     do
  275.     {
  276.       if (!(i&31UL) && index->lines_ok[j] == 0xffffffffUL)
  277.       {
  278.         j++;
  279.         i = (ulong) j<<5;
  280.       }
  281.       else
  282.       {
  283.         i++;
  284.         j = (int) i>>5;
  285.       }
  286.     }
  287.     while (j < 4080 && (index->lines_ok[j] &(1UL <<(i & 31UL))));
  288.  
  289.     end = i;
  290.  
  291.     if (!flag)
  292.     {
  293.       write_ulong (ifile, begin);
  294.       write_ulong (ifile, end);
  295.     }
  296.     else
  297.     {
  298.       for (i = begin; i < end; i++)
  299.       {
  300.         part = (int) i / index->splitsize +1;
  301.         if (part != prevpart)
  302.         {
  303.           if (prevpart)
  304.           {
  305.             if (!(lines % 18) && lines)
  306.               fprintf (ifile, delimit);
  307.             lines = 0;
  308.             fprintf (ifile, "FFF%s", delimit);
  309.           }
  310.           prevpart = part;
  311.           fprintf (ifile, "%02X%s", part, delimit);
  312.         }
  313.  
  314.         lines++; /* Number of missing or corrupted lines in this part. */
  315.         fprintf (ifile, "%03X", (uint)(i % index->splitsize));
  316.         if (!(lines % 18) && lines)
  317.         {
  318.           fprintf (ifile, delimit);
  319.           lines = 0;
  320.         }
  321.         else
  322.           fprintf (ifile, " ");
  323.       }
  324.     }
  325.   }
  326.  
  327.   if (!flag)
  328.   {
  329.     write_ulong (ifile, 0xffffffffUL);
  330.     write_ulong (ifile, index->length);
  331.     #ifdef _CHSIZE_OK
  332.      chsize (fileno (ifile), ftell (ifile));
  333.     #endif
  334.   }
  335.   else
  336.   {
  337.     if (!(lines % 18) && lines)
  338.       fprintf (ifile, delimit);
  339.     fprintf (ifile, "FFF%s", delimit);
  340.   }
  341.   return (0);
  342. }
  343.  
  344. /*
  345. *** Reading/writing unsigned long(32bit)/int(16)
  346. ***
  347. ***
  348.  */
  349.  
  350. ulong read_ulong (FILE *in)
  351. {
  352.   return ((ulong)fgetc (in)       +
  353.          ((ulong)fgetc (in) <<8 ) +
  354.          ((ulong)fgetc (in) <<16) +
  355.          ((ulong)fgetc (in) <<24));
  356. }
  357.  
  358. uint read_uint (FILE *in)
  359. {
  360.   return ((uint)fgetc (in)       +
  361.          ((uint)fgetc (in) <<8 ));
  362. }
  363.  
  364. void write_ulong (FILE *out, ulong val)
  365. {
  366.   my_putc ((int) (val     &0xffUL), out);
  367.   my_putc ((int)((val>>8 )&0xffUL), out);
  368.   my_putc ((int)((val>>16)&0xffUL), out);
  369.   my_putc ((int)((val>>24)&0xffUL), out);
  370. }
  371.  
  372. void write_uint (FILE *out, uint val)
  373. {
  374.   my_putc ((int) (val    &0xffU), out);
  375.   my_putc ((int)((val>>8)&0xffU), out);
  376. }
  377.  
  378. /*
  379. *** read a file, search for s1, calculate CRC until s2 is found.
  380. *** flag == 1: compare calculated an read CRC.
  381. *** flag == 0: insert CRC into file.
  382.  */
  383.  
  384. int crc_file (char *file, char *s1, char *s2, int flag)
  385. {
  386.   char line[81], *p;
  387.   uint crc, cs;
  388.   int i, j, k;
  389.   FILE *in;
  390.  
  391.   crc = cs = 0;
  392.   p = NULLCP;
  393.  
  394.   if (!(in = fopen (file, OPEN_RANDOM_BINARY)))
  395.   {
  396.     printf (cant, file);
  397.     return (2);
  398.   }
  399.  
  400.   i = (int) strlen (s1);
  401.   k = (int) strlen (s2);
  402.  
  403.   j = 1;
  404.  
  405.   do
  406.   {
  407.     if (my_fgets (line, 80, in) == NULL)
  408.       break;
  409.  
  410.     j = strncmp (line, s1, i);
  411.   }
  412.   while (j);
  413.  
  414.   if (j)
  415.     p = s1;
  416.   else
  417.   {
  418.     p = s2;
  419.     do
  420.     {
  421.       for (i=0;i!=(int)strlen(line);i++)
  422.         crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  423.  
  424.       j = strncmp (line, s2, k);
  425.  
  426.       if (!j)
  427.         continue;
  428.  
  429.       if (my_fgets (line, 80, in) == NULL)
  430.         break;
  431.     }
  432.     while (j);
  433.   }
  434.  
  435.   if (j)
  436.   {
  437.     printf ("\n\007Can't calculate CRC\n");
  438.     printf ("String '%s' not found in '%s'.\nBreak.\n", p, file);
  439.     return (7);
  440.   }
  441.  
  442.   /* evaluate CRC */
  443.   if (flag)
  444.   {
  445.     my_fgets (line, 80, in);
  446.     fclose (in);
  447.     if (!line || strncmp ("CRC ", line, 4))
  448.     {
  449.       printf ("\n'%s': no CRC found.\n(File may be corrupted or from version \
  450. earlier than 7PLUS v1.5)\n", file);
  451.       return (17);
  452.     }
  453.     cs = get_hex (line+4);
  454.     if (cs == crc)
  455.       return (0);
  456.  
  457.     printf ("\007\n'%s' is corrupted. Break.\n", file);
  458.     return (7);
  459.   }
  460.  
  461.   /* insert CRC into file */
  462.   fseek (in, 0UL, SEEK_CUR);
  463.   fprintf (in, "CRC %04X", crc);
  464.   fclose (in);
  465.  
  466.   return (0);
  467. }
  468.  
  469. /*
  470. *** Copy a file.
  471. ***
  472. ***
  473.  */
  474.  
  475. int copy_file (char *to, char *from, ulong timestamp)
  476. {
  477.   FILE *_from, *_to;
  478.   int _char, stat;
  479.  
  480.   stat = 0;
  481.  
  482.   _from = fopen (from, OPEN_READ_BINARY);
  483.   _to   = fopen (to,   OPEN_WRITE_BINARY);
  484.  
  485.   while ((_char = getc (_from)) != EOF)
  486.     if ((stat = putc (_char, _to)) == EOF)
  487.       break;
  488.  
  489.   fclose (_from);
  490.  
  491.  #if defined (__MSDOS__) || (__TOS__)
  492.   if (timestamp)
  493.     set_filetime (_to, timestamp);
  494.  
  495.   fclose (_to);
  496.  #else
  497.   fclose (_to);
  498.  
  499.   if (timestamp)
  500.     set_filetime (to, timestamp);
  501.  #endif
  502.  
  503.   if (stat == EOF)
  504.   {
  505.     printf ("\007\nFatal error. Can't write '%s'! Break.\n", to);
  506.     exit (1);
  507.   }
  508.   return (0);
  509. }
  510.  
  511. /*
  512. *** Replace one file with another
  513. ***
  514. ***
  515.  */
  516.  
  517. void replace (char *old, char *new, ulong timestamp)
  518. {
  519.   unlink (old);
  520.  
  521.   if (rename (new, old))
  522.   {
  523.     copy_file (old, new, timestamp);
  524.     unlink (new);
  525.   }
  526.   else
  527.   {
  528.     if (timestamp)
  529.     {
  530.      #if defined (__MSDOS__) || (__TOS__)
  531.       FILE *_file;
  532.  
  533.       _file = fopen (old, OPEN_APPEND_BINARY);
  534.       set_filetime (_file, timestamp);
  535.       fclose (_file);
  536.      #else
  537.       set_filetime (old, timestamp);
  538.      #endif
  539.     }
  540.   }
  541. }
  542.  
  543. /*
  544. *** Kill all files that aren't needed any more
  545. ***
  546. ***
  547.  */
  548.  
  549. void kill_em (char *name, char *inpath, char *one, char *two,
  550.               char *three, char *four, char *five)
  551. {
  552.   char *p, newname[MAXPATH];
  553.   int i, j, k, len;
  554.  
  555.   k = 0;
  556.  
  557.   for (i = 0; i < 5; i++)
  558.   {
  559.     if (!i)
  560.       printf ("\n");
  561.  
  562.     switch (i)
  563.     {
  564.       case 0:  p = one;
  565.                break;
  566.       case 1:  p = two;
  567.                break;
  568.       case 2:  p = three;
  569.                break;
  570.       case 3:  p = four;
  571.                break;
  572.       case 4:  p = five;
  573.  
  574.       default: p = NULLCP;
  575.     }
  576.     if (!p)
  577.      break;
  578.  
  579.     len = strlen(p);
  580.  
  581.     for (j = 1; j <256; j++)
  582.     {
  583.       if (len == 3)
  584.         sprintf (newname, "%s%s.%s", inpath, name, p);
  585.       else
  586.         sprintf (newname, "%s%s.%s%02x", inpath, name, p, j);
  587.  
  588.       if (unlink (newname))
  589.         break;
  590.  
  591.       k++;
  592.  
  593.       printf ("Deleting: %s\r", newname);
  594.       fflush (stdout);
  595.  
  596.       if (len == 3)
  597.         break;
  598.     }
  599.   }
  600.   if (k)
  601.     printf ("\n");
  602. }
  603.  
  604. /*
  605. ***
  606. ***
  607. ***
  608.  */
  609.  
  610. void kill_dest (FILE *in, FILE *out, char *name)
  611. {
  612.     if (out)
  613.       fclose (out);
  614.     if (in)
  615.       fclose (in);
  616.     if (*name)
  617.       unlink (name);
  618. }
  619.  
  620. /*
  621. ***
  622. ***  test if a file exists at all
  623. ***
  624.  */
  625.  
  626. int test_exist (char *filename)
  627. {
  628.   FILE *in = NULLFP;
  629.  
  630.   if ((in = fopen (filename, OPEN_READ_TEXT)) != NULLFP)
  631.   {
  632.     fclose (in);
  633.     return (0);
  634.   }
  635.   return (1);
  636. }
  637.  
  638.  
  639. /*
  640. ***  test if outputfile already exists. prompt for overwrite or
  641. ***  new name.
  642. ***
  643.  */
  644.  
  645. int test_file (FILE *in, char *destnam, int flag, int namsize)
  646. {
  647.    FILE *out;
  648.    int  i, ret;
  649.  
  650.    ret = 0;
  651.  
  652.    if (noquery)
  653.      return (ret);
  654.  
  655.    /* Loop as long as file can be opened. */
  656.    while ((out = fopen (destnam, OPEN_READ_BINARY)) != NULLFP)
  657.    {
  658.      ret = 1;
  659.      printf ("\007\nOutputfile '%s' already exists, overwrite? [y/n/a] ", destnam);
  660.      do
  661.      {
  662.        i = toupper (getch());
  663.  
  664.        if (i == 'N')
  665.        {
  666.          if (flag)
  667.          {
  668.            printf ("%s\n\nEnter new name (max %d chars)\n", no, namsize);
  669.            printf ("or simply press ENTER to break : ");
  670.            if (namsize == 12)
  671.              strlwr (destnam);
  672.            i = getc(stdin);
  673.            if(i != '\n')
  674.            {
  675.              ungetc(i, stdin);
  676.              scanf ("%s", destnam);
  677.            }
  678.            else
  679.              destnam[0] = EOS;
  680.            destnam[namsize] = EOS;
  681.          }
  682.          else
  683.            *destnam = EOS;
  684.          if (!strlen (destnam))
  685.          {
  686.            if (!flag)
  687.              printf ("%s\n", no);
  688.            printf ("Break.\n");
  689.            if (in)
  690.              fclose (in);
  691.            exit (10);
  692.          }
  693.          i = 0xff; /* indicate, that new name has been specified */
  694.        }
  695.      }
  696.      while (i != 'Y' && i != 'A' && i != 0xff);
  697.  
  698.      if (i != 0xff)
  699.      {
  700.        if (i == 'A')
  701.        {
  702.          printf ("%s\n", always);
  703.          noquery = 1;
  704.        }
  705.        else
  706.          printf ("%s\n", yes);
  707.      }
  708.      printf ("\n");
  709.  
  710.      fclose (out);
  711.  
  712.      if (i != 0xff)
  713.        break;
  714.    }
  715.  
  716.    return (ret);
  717. }
  718.  
  719.  
  720. /*
  721. *** initialize decoding table
  722. ***
  723. ***
  724.  */
  725.  
  726. void init_decodetab (void)
  727. {
  728.   register i;
  729.   register byte j;
  730.  
  731.   for (i = 0; i < 256; i++)
  732.     decode[i] = 255;
  733.  
  734.   j = 0;
  735.   for (i = 0x21; i < 0x2a; i++)
  736.     decode[i] = j++;
  737.  
  738.   for (i = 0x2b; i < 0x7f; i++)
  739.     decode[i] = j++;
  740.  
  741.   for (i = 0x80; i < 0x91; i++)
  742.     decode[i] = j++;
  743.  
  744.   decode[0x92] = j++;
  745.  
  746.   for (i = 0x94; i < 0xfd; i++)
  747.     decode[i] = j++;
  748. }
  749.  
  750. /*
  751. *** initialize encoding table
  752. ***
  753. ***
  754.  */
  755.  
  756. void init_codetab (void)
  757. {
  758.   register byte i, j;
  759.  
  760.   j = 0;
  761.  
  762.   for (i = 0x21; i < 0x2a; i++, j++)
  763.     code[j] = i;
  764.  
  765.   for (i = 0x2b; i < 0x7f; i++, j++)
  766.     code[j] = i;
  767.  
  768.   for (i = 0x80; i < 0x91; i++, j++)
  769.     code[j] = i;
  770.  
  771.   code[j++] = 146;
  772.  
  773.   for (i = 0x94; i < 0xfd; i++, j++)
  774.     code[j] = i;
  775. }
  776.  
  777. /*
  778. *** Tnx to DC4OX.
  779. ***
  780. *** calculate CRC-table
  781. ***
  782.  */
  783.  
  784. void init_crctab (void)
  785. {
  786.   uint m, n, r, mask;
  787.  
  788.   static uint bitrmdrs[] = { 0x9188,0x48C4,0x2462,0x1231,
  789.                              0x8108,0x4084,0x2042,0x1021 };
  790.  
  791.   for (n = 0; n < 256; ++n)
  792.   {
  793.     for (mask = 0x0080, r = 0, m = 0; m < 8; ++m, mask >>= 1)
  794.       if (n & mask)
  795.         r = bitrmdrs[m] ^ r;
  796.     crctab[n] = r;
  797.   }
  798. }
  799.  
  800. /*
  801. *** Create a MSDOS/ATARI compatible filename.
  802. ***
  803. ***
  804.  */
  805.  
  806. void build_DOS_name (char *name)
  807. {
  808.   char tmp[MAXFNAME];
  809.   register i, j;
  810.  
  811.   i = j = 0;
  812.  
  813.   strcpy (tmp, name);
  814.   strlwr (tmp);
  815.  
  816.   if (*tmp)
  817.   {
  818.     do
  819.     {
  820.       tmp[i] &= 127;
  821.       if (strchr (" <>=,;:*?&[]()/.\\\"~+@", tmp[i]) == NULL)
  822.         name[j++] = tmp[i];
  823.     }
  824.     while (tmp[++i]);
  825.  
  826.     name[j] = EOS;
  827.   }
  828. }
  829.  
  830. #if defined (__MSDOS__) || (__TOS__)
  831.  /*
  832.  *** Get file's timestamp and package it into a 32-bit word (MS_DOS-format)
  833.  ***
  834.  ***
  835.   */
  836.  ulong get_filetime (FILE *_file)
  837.  {
  838.   ulong    ftimestamp;
  839.  
  840.   if (getftime (fileno(_file), (struct ftime *)&ftimestamp) == EOF)
  841.     printf ("\007\nCan't get file's timestamp!\n");
  842.  
  843.  #ifdef __TOS__
  844.   ftimestamp = swapl(ftimestamp);
  845.  #endif
  846.  
  847.   return (ftimestamp);
  848.  }
  849.  
  850.  /*
  851.  *** Set file's timestamp
  852.  ***
  853.  ***
  854.   */
  855.  void set_filetime (FILE *_file, ulong ftimestamp)
  856.  {
  857.  #ifdef __TOS__
  858.   ftimestamp = swapl(ftimestamp);
  859.  #endif
  860.  
  861.   if (setftime (fileno(_file), (struct ftime *)&ftimestamp) == EOF)
  862.     printf ("\007\nCan't set file's timestamp!");
  863.  }
  864. #else
  865.  #ifndef _HAVE_GMTIME
  866.   /*
  867.   * mktime function from GNU C library V1.03; modified:
  868.   * - expanded DEFUN and CONST macros from ansidecl.h
  869.   * - inserted __isleap macro from time.h
  870.   * - inserted __mon_lengths array and __offtime function from offtime.c
  871.   * - inserted gmtime function from gmtime.c
  872.   * - commented out call of localtime function
  873.   * Be aware of the following copyright message for mktime !!!
  874.   */
  875.  
  876.   /* Copyright (C) 1991 Free Software Foundation, Inc.
  877.   This file is part of the GNU C Library.
  878.  
  879.   The GNU C Library is free software; you can redistribute it and/or
  880.   modify it under the terms of the GNU Library General Public License as
  881.   published by the Free Software Foundation; either version 2 of the
  882.   License, or (at your option) any later version.
  883.  
  884.   The GNU C Library is distributed in the hope that it will be useful,
  885.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  886.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  887.   Library General Public License for more details.
  888.  
  889.   You should have received a copy of the GNU Library General Public
  890.   License along with the GNU C Library; see the file COPYING.LIB.  If
  891.   not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  892.   Cambridge, MA 02139, USA.  */
  893.  
  894.  
  895.   /* How many days are in each month.  */
  896.   const unsigned short int __mon_lengths[2][12] =
  897.     {
  898.       /* Normal years.  */
  899.       { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  900.       /* Leap years.  */
  901.       { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  902.     };
  903.  
  904.   #define  __isleap(year)  \
  905.     ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
  906.  
  907.   #define  invalid()  return (time_t) -1
  908.  
  909.  
  910.   #define  SECS_PER_HOUR  (60 * 60)
  911.   #define  SECS_PER_DAY  (SECS_PER_HOUR * 24)
  912.  
  913.   /* Returns the `struct tm' representation of *T,
  914.      offset OFFSET seconds east of UCT.  */
  915.   struct tm *
  916.   __offtime (const time_t *t, long int offset)
  917.   {
  918.     static struct tm tbuf;
  919.     register long int days, rem;
  920.     register int y;
  921.     register const unsigned short int *ip;
  922.  
  923.     if (t == NULL)
  924.       return NULL;
  925.  
  926.     days = *t / SECS_PER_DAY;
  927.     rem = *t % SECS_PER_DAY;
  928.     rem += offset;
  929.     while (rem < 0)
  930.     {
  931.       rem += SECS_PER_DAY;
  932.       --days;
  933.     }
  934.     while (rem >= SECS_PER_DAY)
  935.     {
  936.       rem -= SECS_PER_DAY;
  937.       ++days;
  938.     }
  939.     tbuf.tm_hour = rem / SECS_PER_HOUR;
  940.     rem %= SECS_PER_HOUR;
  941.     tbuf.tm_min = rem / 60;
  942.     tbuf.tm_sec = rem % 60;
  943.     /* January 1, 1970 was a Thursday.  */
  944.     tbuf.tm_wday = (4 + days) % 7;
  945.     if (tbuf.tm_wday < 0)
  946.       tbuf.tm_wday += 7;
  947.     y = 1970;
  948.     while (days >= (rem = __isleap(y) ? 366 : 365))
  949.     {
  950.       ++y;
  951.       days -= rem;
  952.     }
  953.     while (days < 0)
  954.     {
  955.       --y;
  956.       days += __isleap(y) ? 366 : 365;
  957.     }
  958.     tbuf.tm_year = y - 1900;
  959.     tbuf.tm_yday = days;
  960.     ip = __mon_lengths[__isleap(y)];
  961.     for (y = 0; days >= ip[y]; ++y)
  962.       days -= ip[y];
  963.     tbuf.tm_mon = y;
  964.     tbuf.tm_mday = days + 1;
  965.     tbuf.tm_isdst = -1;
  966.  
  967.     return &tbuf;
  968.   }
  969.  
  970.  
  971.   /* Return the `struct tm' representation of *T in UTC.  */
  972.   struct tm *
  973.   gmtime (const time_t *t)
  974.   {
  975.     return __offtime(t, 0L);
  976.   }
  977.  #endif /* ifndef _HAVE_GMTIME */
  978.  
  979.  #ifndef _HAVE_MKTIME
  980.  
  981.   /* Return the `time_t' representation of TP and normalizes TP.
  982.      Return (time_t) -1 if TP is not representable as a `time_t'.
  983.      Note that 31 Dec 1969 23:59:59 is not representable
  984.      because it is represented as (time_t) -1.  */
  985.   time_t mktime (register struct tm *tp)
  986.   {
  987.     static struct tm min, max;
  988.     static char init = 0;
  989.  
  990.     register time_t result;
  991.     register time_t t;
  992.     register int i;
  993.     register const unsigned short *l;
  994.     register struct tm *new;
  995.     time_t end;
  996.  
  997.     if (tp == NULL)
  998.     {
  999.       errno = EINVAL;
  1000.       invalid();
  1001.     }
  1002.  
  1003.     if (!init)
  1004.     {
  1005.       init = 1;
  1006.       end = (time_t) LONG_MIN;
  1007.       new = gmtime(&end);
  1008.       if (new != NULL)
  1009.         min = *new;
  1010.       else
  1011.         min.tm_sec = min.tm_min = min.tm_hour =
  1012.       min.tm_mday = min.tm_mon = min.tm_year = INT_MIN;
  1013.  
  1014.       end = (time_t) LONG_MAX;
  1015.       new = gmtime(&end);
  1016.       if (new != NULL)
  1017.         max = *new;
  1018.       else
  1019.         max.tm_sec = max.tm_min = max.tm_hour =
  1020.       max.tm_mday = max.tm_mon = max.tm_year = INT_MAX;
  1021.     }
  1022.  
  1023.     /* Make all the elements of TP that we pay attention to
  1024.        be within the ranges of reasonable values for those things.  */
  1025.     #define  normalize(elt, min, max, nextelt)\
  1026.     while (tp->elt < min)                     \
  1027.     {                                         \
  1028.       --tp->nextelt;                          \
  1029.       tp->elt += max + 1;                     \
  1030.     }                                         \
  1031.     while (tp->elt > max)                     \
  1032.     {                                         \
  1033.       ++tp->nextelt;                          \
  1034.       tp->elt -= max + 1;                     \
  1035.     }
  1036.  
  1037.     normalize (tm_sec, 0, 59, tm_min);
  1038.     normalize (tm_min, 0, 59, tm_hour);
  1039.     normalize (tm_hour, 0, 24, tm_mday);
  1040.  
  1041.     /* Normalize the month first so we can use
  1042.        it to figure the range for the day.  */
  1043.     normalize (tm_mon, 0, 11, tm_year);
  1044.     normalize (tm_mday, 1, __mon_lengths[__isleap (tp->tm_year)][tp->tm_mon],
  1045.       tm_mon);
  1046.  
  1047.     /* Normalize the month again, since normalizing
  1048.        the day may have pushed it out of range.  */
  1049.     normalize (tm_mon, 0, 11, tm_year);
  1050.  
  1051.     /* Normalize the day again, because normalizing
  1052.        the month may have changed the range.  */
  1053.     normalize (tm_mday, 1, __mon_lengths[__isleap (tp->tm_year)][tp->tm_mon],
  1054.       tm_mon);
  1055.  
  1056.    /* Check for out-of-range values.  */
  1057.    #define  lowhigh(field, minmax, cmp)  (tp->field cmp minmax.field)
  1058.    #define  low(field)                   lowhigh(field, min, <)
  1059.    #define  high(field)                  lowhigh(field, max, >)
  1060.    #define  oor(field)                   (low(field) || high(field))
  1061.    #define  lowbound(field)              (tp->field == min.field)
  1062.    #define  highbound(field)             (tp->field == max.field)
  1063.    if (oor(tm_year))
  1064.      invalid();
  1065.    else
  1066.      if (lowbound(tm_year))
  1067.      {
  1068.        if (low(tm_mon))
  1069.          invalid();
  1070.        else
  1071.          if (lowbound(tm_mon))
  1072.          {
  1073.            if (low(tm_mday))
  1074.              invalid();
  1075.            else
  1076.              if (lowbound(tm_mday))
  1077.              {
  1078.                if (low(tm_hour))
  1079.                  invalid();
  1080.                else
  1081.                  if (lowbound(tm_hour))
  1082.                  {
  1083.                    if (low(tm_min))
  1084.                      invalid();
  1085.                    else
  1086.                      if (lowbound(tm_min))
  1087.                      {
  1088.                        if (low(tm_sec))
  1089.                        invalid();
  1090.                      }
  1091.                  }
  1092.              }
  1093.          }
  1094.      }
  1095.      else
  1096.        if (highbound(tm_year))
  1097.        {
  1098.          if (high(tm_mon))
  1099.            invalid();
  1100.          else
  1101.            if (highbound(tm_mon))
  1102.            {
  1103.              if (high(tm_mday))
  1104.                invalid();
  1105.              else
  1106.                if (highbound(tm_mday))
  1107.                {
  1108.                  if (high(tm_hour))
  1109.                    invalid();
  1110.                  else
  1111.                    if (highbound(tm_hour))
  1112.                    {
  1113.                      if (high(tm_min))
  1114.                        invalid();
  1115.                      else
  1116.                        if (highbound(tm_min))
  1117.                        {
  1118.                          if (high(tm_sec))
  1119.                          invalid();
  1120.                        }
  1121.                    }
  1122.                }
  1123.            }
  1124.        }
  1125.     t = 0;
  1126.     for (i = 1970; i > 1900 + tp->tm_year; --i)
  1127.       t -= __isleap(i) ? 366 : 365;
  1128.     for (i = 1970; i < 1900 + tp->tm_year; ++i)
  1129.       t += __isleap(i) ? 366 : 365;
  1130.     l = __mon_lengths[__isleap(1900 + tp->tm_year)];
  1131.     for (i = 0; i < tp->tm_mon; ++i)
  1132.       t += l[i];
  1133.     t += tp->tm_mday - 1;
  1134.     result = ((t * 60 * 60 * 24) +
  1135.              (tp->tm_hour * 60 * 60) +
  1136.              (tp->tm_min * 60) +
  1137.               tp->tm_sec);
  1138.  
  1139.     end = result;
  1140.    #if 0
  1141.     if (tp->tm_isdst < 0)
  1142.       new = localtime(&end);
  1143.     else
  1144.    #endif
  1145.       new = gmtime(&end);
  1146.     if (new == NULL)
  1147.       invalid();
  1148.     new->tm_isdst = tp->tm_isdst;
  1149.     *tp = *new;
  1150.  
  1151.     return result;
  1152.   }
  1153.  #endif /* ifndef _HAVE_MKTIME */
  1154.  
  1155.  #ifndef _FTIMEDEFINED
  1156.   /*
  1157.    * these functions have to convert a MS/DOS time to a UNIX time
  1158.    * and vice versa.
  1159.    * here comes the MS/DOS time structure
  1160.    */
  1161.   struct ftime
  1162.   {
  1163.     unsigned  ft_tsec  : 5;   /* 0..59 /2 (!) */
  1164.     unsigned  ft_min   : 6;   /* 0..59 */
  1165.     unsigned  ft_hour  : 5;   /* 0..23 */
  1166.     unsigned  ft_day   : 5;   /* 1..31 */
  1167.     unsigned  ft_month : 4;   /* 1..12 */
  1168.     unsigned  ft_year  : 7; /* Year minus 1980 */
  1169.   };
  1170.  #endif
  1171.  
  1172.  /*
  1173.   * Get file's timestamp and package it into a 32-bit word (MS_DOS-format).
  1174.   * This function should work on any system :-)
  1175.   */
  1176.  ulong get_filetime (char *filename)
  1177.  {
  1178.    struct ftime fti;
  1179.    ulong *retval = (ulong *) &fti;
  1180.    struct tm *utm;
  1181.    struct stat fst;
  1182.  
  1183.    *retval = 0UL;
  1184.  
  1185.    /* get file status */
  1186.    if (stat (filename, &fst) == 0)
  1187.    {
  1188.       /* get time of last modification and convert it to MS/DOS time */
  1189.      utm = gmtime (&fst.st_mtime);
  1190.  
  1191.      if (utm)
  1192.      {
  1193.        fti.ft_tsec  = utm->tm_sec / 2;
  1194.        fti.ft_min   = utm->tm_min;
  1195.        fti.ft_hour  = utm->tm_hour;
  1196.        fti.ft_day   = utm->tm_mday;
  1197.        fti.ft_month = utm->tm_mon + 1;
  1198.        fti.ft_year  = utm->tm_year - 80;
  1199.        return (*retval);
  1200.      }
  1201.    }
  1202.  
  1203.    /* error exit */
  1204.    printf ("\007\nCan't get file's timestamp!\n");
  1205.    return (*retval);
  1206.  }
  1207.  #ifdef __unix__
  1208.   /*
  1209.    * Set file's timestamp
  1210.    * This function only works on UNIX-systems
  1211.    */
  1212.   void set_filetime (char *filename, ulong ftimestamp)
  1213.   {
  1214.     time_t atime;
  1215.     struct utimbuf utim;
  1216.     struct ftime *fti;
  1217.     struct tm utm;
  1218.  
  1219.     /* convert MS/DOS ftimestamp to UNIX atime */
  1220.     fti = (struct ftime *) &ftimestamp;
  1221.     utm.tm_sec   = fti->ft_tsec * 2;
  1222.     utm.tm_min   = fti->ft_min;
  1223.     utm.tm_hour  = fti->ft_hour;
  1224.     utm.tm_mday  = fti->ft_day;
  1225.     utm.tm_mon   = fti->ft_month - 1;
  1226.     utm.tm_year  = fti->ft_year + 80;
  1227.     utm.tm_wday  = utm.tm_yday  =  utm.tm_isdst = 0;
  1228.     atime = mktime (&utm);
  1229.  
  1230.     if (atime != -1)
  1231.     {
  1232.       /* set access time and modification time */
  1233.       utim.actime = atime;
  1234.       utim.modtime = atime;
  1235.       if (utime (filename, &utim) >= 0)
  1236.         return;
  1237.     }
  1238.  
  1239.     /* error exit */
  1240.     printf ("\007\nCan't set file's timestamp!");
  1241.     return;
  1242.   }
  1243.  #else /* not UNIX */
  1244.   /*
  1245.    * Set file's timestamp
  1246.    *
  1247.    */
  1248.   void set_filetime (char *filename, ulong ftimestamp)
  1249.   {
  1250.     /* error exit */
  1251.     printf ("\007\nset_filetime not (yet) implemented on this system!");
  1252.     return;
  1253.   }
  1254.  #endif /* __unix__ */
  1255. #endif /* __MSDOS__ or __TOS__ */
  1256.  
  1257.  
  1258. /*
  1259. *** get_hex: some compilers have real big trouble when reading hex values from
  1260. ***          a file with fscanf() that have leading zeros! e.g. 00A will be
  1261. ***          read as two separate values (0 and A)! grr!!
  1262. ***          get_hex skips all leading zeros to eliminate the problem.
  1263. ***
  1264.  */
  1265.  
  1266. uint get_hex (char *hex)
  1267. {
  1268.   register i = 0;
  1269.   uint   ret = 0;
  1270.  
  1271.   while (hex[i] == '0')
  1272.     i++;
  1273.   sscanf(hex+i, "%x", &ret);
  1274.   return (ret);
  1275. }
  1276.  
  1277.  
  1278. #ifdef _FNSPLIT
  1279. /*
  1280. ***       filenamesplit
  1281. ***       (by DL1MEN, taken from SP-ST, modified for portability)
  1282. ***
  1283. ***       split filename up into drive, path, name and extension.
  1284. ***
  1285.  */
  1286.  
  1287. void fnsplit(char *pth, char *dr, char *pa, char *fn, char *ft)
  1288. {
  1289.   char drv[MAXDRIVE], pat[MAXDIR], fna[MAXFILE], fty[MAXEXT], tmp[MAXPATH];
  1290.   char *p;
  1291.  
  1292.   strcpy(tmp,pth);
  1293.  
  1294.   if ((p = strchr(tmp,':')) != NULL)
  1295.   {
  1296.     *p++ = EOS;
  1297.     strcpy(drv,tmp);
  1298.   }
  1299.   else
  1300.   {
  1301.     p = tmp;
  1302.     drv[0] = EOS;
  1303.   }
  1304.   if ((pth = strrchr(p, PATHCHAR)) != NULL)
  1305.   {
  1306.     *pth++ = EOS;
  1307.     strcpy(pat,p);
  1308.   }
  1309.   else
  1310.   {
  1311.     pth = p;
  1312.     pat[0] = EOS;
  1313.   }
  1314.   if ((p = strchr(pth,'.')) != NULL)
  1315.   {
  1316.     strcpy(fty,p);
  1317.     fty[MAXEXT-1] = EOS;
  1318.     *p = EOS;
  1319.   }
  1320.   else
  1321.     fty[0] = EOS;
  1322.  
  1323.   strcpy(fna,pth);
  1324.   fna[MAXFILE-1] = EOS;
  1325.  
  1326.   if (dr)
  1327.   {
  1328.     strcpy(dr,drv);
  1329.     if (drv[0])
  1330.       strcat(dr,":");
  1331.   }
  1332.   if (pa)
  1333.   {
  1334.     strcpy(pa,pat);
  1335.     if (pat[0])
  1336.       strcat(pa, PATHSEP);
  1337.   }
  1338.   if (fn)
  1339.     strcpy(fn,fna);
  1340.   if (ft)
  1341.    strcpy(ft,fty);
  1342. }
  1343. #endif /** _FNSPLIT **/
  1344.  
  1345. #ifdef _ICMP
  1346. /* The following functions are unfortunately not avialable on all compilers */
  1347.  
  1348. /*
  1349. *** strupr - convert string to upper case.
  1350. ***
  1351. ***
  1352.  */
  1353.  
  1354. char *strupr (char *string)
  1355. {
  1356.   char *strcnvt (char *string, int flag);
  1357.  
  1358.   return (strcnvt (string, 1));
  1359. }
  1360.  
  1361. /*
  1362. *** strlwr - convert string to lower case.
  1363. ***
  1364. ***
  1365.  */
  1366.  
  1367. char *strlwr (char *string)
  1368. {
  1369.   char *strcnvt (char *string, int flag);
  1370.  
  1371.   return (strcnvt (string, 0));
  1372. }
  1373.  
  1374. /*
  1375. *** strcnvt - convert string to upper (flag == 1) or lower (flag == 0) case.
  1376. ***
  1377. ***
  1378.  */
  1379.  
  1380. char *strcnvt (char *string, int flag)
  1381. {
  1382.   register i = 0;
  1383.  
  1384.   while (string[i])
  1385.   {  
  1386.     string[i] = (flag)?toupper (string[i]):tolower (string[i]);
  1387.     i++;
  1388.   }
  1389.  
  1390.   return (string);
  1391. }
  1392.  
  1393. /*
  1394. *** stricmp - same as strcmp(), but ignores case.
  1395. *** s1 and s2 are not modified.
  1396. ***
  1397.  */
  1398.  
  1399. int stricmp (const char *s1, const char *s2)
  1400. {
  1401.   return (strnicmp (s1, s2, (size_t) 80));
  1402. }
  1403.  
  1404. /*
  1405. *** strnicmp - same as strncmp(), but ignores case.
  1406. *** s1 and s2 are not modified.
  1407. ***
  1408.  */
  1409.  
  1410. int strnicmp (const char *s1, const char *s2, size_t n)
  1411. {
  1412.   char _s1[81], _s2[81];
  1413.  
  1414.   strncpy (_s1, s1, 80);
  1415.   strncpy (_s2, s2, 80);
  1416.   strupr (_s1);
  1417.   strupr (_s2);
  1418.  
  1419.   return (strncmp (_s1, _s2, n));
  1420. }
  1421. #endif /** _ICMP **/
  1422.